using System;
using System.Collections.Generic;
using System.Text;
using RC.ControlAcceso.BaseDatos;
using System.Data;
using RC.CodigoBarras.Utiles;

namespace RC.ControlAcceso.ObjetosNegocio
{
    public class CA2Cargo
    {
        #region Variables
        private int _idCargo;
        private int _idSector;
        private string _descripcion;
        private bool _estaActivo;
        
        // objeto de base de datos
        CACargoBD mCargoBD;
                
        #endregion

        #region Propiedades
        
        public int IdCargo
        {
            get { return _idCargo; }
            set { _idCargo = value; }
        }
        public int IdSector
        {
            get { return _idSector; }
            set { _idSector = value; }
        }
        public string Descripcion
        {
            get { return _descripcion; }
            set { _descripcion = value; }
        }
        public bool EstaActivo
        {
            get { return _estaActivo; }
            set { _estaActivo = value; }
        }
        #endregion

        #region Constructores
        public CA2Cargo()
        {
            IdCargo = -1;
            IdSector = -1;
            Descripcion = "";
            EstaActivo = true;
        }        
        public CA2Cargo(int pIdCargo)
        {
            mCargoBD = new CACargoBD(pIdCargo);
            AsignarBDaON();
        }
        #endregion

        #region Funciones
        
        /// <summary>
        /// Agrega un Cargo.
        /// </summary>
        /// <returns>No devuelve nada.</returns>
        public void Insertar()
        {            
            AsignarONaBD();
            mCargoBD.IdCargo = mCargoBD.Insertar();
            IdCargo = mCargoBD.IdCargo;
        }
        /// <summary>
        /// Actualiza el objeto.
        /// </summary>
        /// <returns>No devuelve nada.</returns>
        public void Actualizar()
        {
            AsignarONaBD();
            mCargoBD.Actualizar();
        }
        /// <summary>
        /// Carga un objeto.
        /// </summary>
        /// <returns>No devuelve nada.</returns>
        public void Editar()
        {
            AsignarONaBD();
            mCargoBD.Editar();
            AsignarBDaON();
        }
        
        
        /// <summary>
        /// Asigna los objetos de la base de datos a el objeto de nengocio
        /// </summary>
        private void AsignarBDaON()
        {
            IdCargo = mCargoBD.IdCargo;
            IdSector = mCargoBD.IdSector;
            Descripcion = mCargoBD.Descripcion;
            EstaActivo = mCargoBD.EstaActivo;
        }
        /// <summary>
        /// Asigna los objetos de negocio a base de datos
        /// </summary>
        private void AsignarONaBD()
        {
            if (mCargoBD == null)
                mCargoBD = new CACargoBD();
            mCargoBD.IdCargo = IdCargo;
            mCargoBD.IdSector = IdSector;
            mCargoBD.Descripcion = Descripcion;
            mCargoBD.EstaActivo = EstaActivo;
        }
        public CA2Cargo AsignarRowACargo(DataRow pRow)
        {
            CA2Cargo _Cargo = new CA2Cargo();


            _Cargo.IdCargo = int.Parse(pRow["IdCargo"].ToString());

            try { _Cargo.IdSector = int.Parse(pRow["IdSector"].ToString()); }
            catch { _Cargo.IdSector = -1; }

            _Cargo.Descripcion = pRow["Descripcion"].ToString();

            try { _Cargo.EstaActivo = bool.Parse(pRow["EstaActivo"].ToString()); }
            catch { _Cargo.EstaActivo = true; }

            return _Cargo;
        }
        #endregion
    }
    public class CA2CargoColeccion : System.Collections.CollectionBase
    {
        public void Add(CA2Cargo pCargo)
        {
            this.List.Add(pCargo);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public CA2Cargo this[int index]
        {
            get { return ((CA2Cargo)(this.List[index])); }
            set { this.List[index] = value; }
        }
        
        /// <summary>
        /// Obtiene todas las Cargos
        /// </summary>
        public CA2CargoColeccion ObtenerTodasLasCargos()
        {
            CACargoBD _Cargo = new CACargoBD();
            DataSet _CargosDS = _Cargo.ObtenerTodos();
            return AsignarDatasetAColeccion(_CargosDS);
        }
        /// <summary>
        /// Asigna los valores del dataset a el objeto coleccion.
        /// </summary>
        /// <param name="pDSLegajos"></param>
        /// <returns></returns>
        private CA2CargoColeccion AsignarDatasetAColeccion(DataSet pCargosDS)
        {
            if ((pCargosDS == null) || (pCargosDS.Tables[0].Rows.Count == 0))
                return null;

            CA2CargoColeccion _resultado = new CA2CargoColeccion();
            CA2Cargo _Cargo = new CA2Cargo(); //lo creo aca por que tengo que usar solamente un metodo que tiene 

            // recorro todas las filas y cargo los objetos
            foreach (DataRow _row in pCargosDS.Tables[0].Rows)
            {
                // asigno los valores a el objeto y el objeto a la coleccion
                _resultado.Add(_Cargo.AsignarRowACargo(_row));
            }

            return _resultado;

        }
        /// <summary>
        /// Obtiene todas las Cargos activas utilizables
        /// </summary>
        /// <returns></returns>
        private CA2CargoColeccion ObtenerCargosActivos()
        {
            CA2CargoColeccion _resultado = new CA2CargoColeccion();
            foreach (CA2Cargo _Cargo in this)            
                if (_Cargo.EstaActivo == true)
                    _resultado.Add(_Cargo);

            return _resultado;
        }
        /// <summary>
        /// Devuelve el objeto Cargo que corresponde al nombre especificado.
        /// Si la Cargo no existe, devuel Null.
        /// </summary>
        /// <param name="pNombreCargo"></param>
        /// <returns></returns>
        public CA2Cargo ObtenerCargoPorNombre(string pNombreCargo)
        {
            foreach (CA2Cargo _Cargo in this)
                try
                {
                    if (_Cargo.Descripcion.ToUpper() == pNombreCargo.ToUpper())
                        return _Cargo;
                }
                catch { }

            // si no lo encuentra devuelve vacio
            return null;
        }
        /// <summary>
        /// Actualiza el cargo proporcionado
        /// </summary>
        /// <param name="pCargo"></param>
        /// <returns></returns>
        public bool ActualizarCargo(CA2Cargo pCargo)
        {
            pCargo.Actualizar();
            return true;
        }
        /// <summary>
        /// Elimina la Cargo seleccionada.
        /// </summary>
        /// <param name="pCargo"></param>
        /// <returns></returns>
        public bool EliminarCargo(CA2Cargo pCargo)
        {
            CA2Cargo _Cargo = new CA2Cargo(pCargo.IdCargo);
            _Cargo.EstaActivo = false;
            _Cargo.Actualizar();
            return true;
        }

    }
}